

// 单元结构体: 不关心该类型的内容, 只关心它的行为。
struct Solution {}

impl Solution {
    pub fn min_non_zero_product(p: i32) -> i32 {
        fn fast_pow(mut x: i64, mut n: i64, mod_val: i64) -> i64 {
            let mod_val = mod_val as i64;
            let mut res = 1;
            while n != 0 {
                if n & 1 == 1 {
                    res = (res * x) % mod_val;
                }
                x = (x * x) % mod_val;
                n >>= 1;
            }
            res
        }

        if p == 1 {
            return 1;
        }
        let mod_val = 1_000_000_007;
        let x = fast_pow(2, p as i64, mod_val) - 1;
        let y = 1i64 << (p - 1);
        (fast_pow(x-1, y-1, mod_val) * x % mod_val) as i32
    }
}

// impl Solution {
//     pub fn find_the_array_conc_val(nums: Vec<i32>) -> i64 {
//         let mut ans = 0;
//         let mut i = 0;
//         let mut j = nums.len() - 1;
//         while i <= j {
//             if i != j {
//                 ans += format!("{}{}", nums[i], nums[j]).parse::<i64>().unwrap();
//             } else {
//                 ans += nums[i] as i64;
//             }
//             i += 1;
//             j -= 1;
//         }
//         // return ans;
//         ans
//     }
//
//     pub fn maximum_score(nums: Vec<i32>, k: i32) -> i32 {
//         let n = nums.len() as i32;
//         let mut left = k as i32 - 1;
//         let mut right = k + 1;
//         let mut ans = 0;
//         let mut i = nums[k as usize];
//         // while true
//         loop {
//             while left >= 0 && left < n && nums[left as usize] >= i {
//                 left -= 1;
//             }
//             while right < n && nums[right as usize] >= i {
//                 right += 1;
//             }
//             ans = ans.max((right - left - 1) * i);
//             if left == -1 && right == n {
//                 break;
//             }
//             let lval = if left == -1 { -1 } else { nums[left as usize] };
//             let rval = if right == n { -1 } else { nums[right as usize] };
//             i = lval.max(rval);
//             if i == -1 {
//                 break;
//             }
//         }
//         ans
//     }
// }